class Set {
    constructor() {
        this.items = {};
    }
    //检查集合中是否有指定元素
    has(element) {
        //这里指向的是this.item的原型链。
        return Object.prototype.hasOwnProperty.call(this.items, element)
        // return element in this.items
    }
    //添加一个集合元素的时候，把它同时作为键和值保存，有利于查找该元素
    add(element) {
        if (!this.has(element)) {
            this.items[element] = element;
            return true;
        }
        return false;
    }
    //删除方法
    delete(element) {
        if (this.has(element)) {
            delete this.items[element];
            return true;
        }
        return false;
    }
    
    // clear方法移除所有值
    clear() {
        this.items = {};
    }

    // size方法判断长度
    size() {
        // 返回key是个数组，但是不适用于所有浏览器
        // return Object.keys(this.items).length;
        let count = 0;
        for (let key in this.items) {
            // 检查自身属性
            if (this.items.hasOwnProperty(key)) {
                count++
            }
        }
        return count
    }

    // values方法
    values() {
        // Object.values方法返回了一个包含给定对象所有属性值的数组
        return Object.values(this.items)
    }
    // 并集
    union(otherSet) {
        const unionSet = new Set();
        this.values().forEach(value => { unionSet.add(value) });
        otherSet.values().forEach(value => { unionSet.add(value) });
        return unionSet;
    }
    // 交集
    Intersection(otherSet) {
        const interset = new Set();
        const values = this.values();
        for (let i = 0; i < values.length; i++) {
            if (otherSet.has(values[i])) {
                interset.add(values[i])
            }
        }
        return interset;
    }
    //差集
    difference(otherSet) {
        const differenceSet = new Set();
        this.values().forEach(value => {
            if (!otherSet.has(value)) {
                differenceSet.add(value);
            }
        })
        return differenceSet;
    }
    //子集
    issubset(otherSet) {
        if (this.size() > otherSet.size()) {
            return false;
        }
        let issubsets = true;
        this.values().every(value => {
            if (!otherSet.has(value)) {
                issubsets = false;
                return false;
            }
            return true;
        })
        return issubsets;
    }
}
const seta = new Set();
seta.add(1)
seta.add(2)
seta.add(3)
const setb = new Set();
setb.add(1)
setb.add(2)
// console.log(seta.values()); 
const ina = setb.issubset(seta);
console.log(ina);
//使用扩展运算符来进行并集运算,其中seta和setb是集合
console.log(new Set([...seta, ...setb]));
//使用扩展运算符进行交集运算
console.log(new Set([...seta].filter(x => { setb.has(x) })));
//使用扩展运算符完成差集运算
console.log(new Set([...seta].filter(x => !setb.has(x))));
